+2000-10-04 Havoc Pennington <hp@redhat.com>
+
+ * gtk/testgtk.c (create_buttons): create some stock buttons
+ with the default accel group
+ (create_image): test some new GtkImage features
+ (make_message_dialog): test GtkMessageDialog
+ (create_modal_window): fix someone's bizzarro indentation
+
+ * gtk/gtkwindow.h, gtk/gtkwindow.c: Implement
+ GTK_WIN_POS_CENTER_ON_PARENT.
+ Add "destroy with parent" setting, which means the window goes
+ away with its transient parent.
+ (gtk_window_get_default_accel_group): get the default accel group
+ for the window.
+ (gtk_window_set_destroy_with_parent): set/unset destroy with
+ parent flag
+ (gtk_window_read_rcfiles): invalidate icon set caches
+ after reloading rcfiles
+
+ * gtk/gtkenums.h (GtkWindowPosition): add
+ GTK_WIN_POS_CENTER_ON_PARENT, which centers a dialog
+ on its parent window when the dialog is mapped for the first time.
+
+ * gtk/gtkmessagedialog.h, gtk/gtkmessagedialog.c: Add
+ a simple message dialog class
+
+ * gtk/gtkdialog.c (gtk_dialog_init): Connect delete event
+ handler to emit response signal, and maybe later it would
+ honor a hide_on_delete flag - though that isn't there yet.
+ Set border width on the vbox to 2, so we get some padding.
+ Use a button box for the action area.
+ (gtk_dialog_key_press): synthesize a delete event if Esc
+ is pressed and the GtkWidget key press handler didn't
+ handle the escape key.
+ (gtk_dialog_new_with_buttons): new function creates a dialog
+ with some default buttons in it.
+ (gtk_dialog_add_action_widget): add an activatable widget
+ as a button in the dialog - you can also add a non-activatable
+ widget by accessing the action area directly.
+ (gtk_dialog_add_button): add a simple button - stock ID or
+ label - to the action area
+ (gtk_dialog_response): emit response signal
+ (gtk_dialog_run): block waiting for the dialog, return
+ the response. Override normal delete_event behavior, so that
+ delete_event does nothing inside gtk_dialog_run().
+
+ * gtk/gtkdialog.h, gtk/gtkdialog.c: Add "response" signal
+ emitted when an action widget is clicked or the dialog gets
+ delete_event
+
+ * gtk/gtk.h: add gtkmessagedialog.h
+
+ * gtk/Makefile.am: add gtkmessagedialog.[hc]
+
2000-10-18 Havoc Pennington <hp@redhat.com>
* gtk/gtktextiter.c (gtk_text_iter_forward_to_newline): Fix a bug
+2000-10-04 Havoc Pennington <hp@redhat.com>
+
+ * gtk/testgtk.c (create_buttons): create some stock buttons
+ with the default accel group
+ (create_image): test some new GtkImage features
+ (make_message_dialog): test GtkMessageDialog
+ (create_modal_window): fix someone's bizzarro indentation
+
+ * gtk/gtkwindow.h, gtk/gtkwindow.c: Implement
+ GTK_WIN_POS_CENTER_ON_PARENT.
+ Add "destroy with parent" setting, which means the window goes
+ away with its transient parent.
+ (gtk_window_get_default_accel_group): get the default accel group
+ for the window.
+ (gtk_window_set_destroy_with_parent): set/unset destroy with
+ parent flag
+ (gtk_window_read_rcfiles): invalidate icon set caches
+ after reloading rcfiles
+
+ * gtk/gtkenums.h (GtkWindowPosition): add
+ GTK_WIN_POS_CENTER_ON_PARENT, which centers a dialog
+ on its parent window when the dialog is mapped for the first time.
+
+ * gtk/gtkmessagedialog.h, gtk/gtkmessagedialog.c: Add
+ a simple message dialog class
+
+ * gtk/gtkdialog.c (gtk_dialog_init): Connect delete event
+ handler to emit response signal, and maybe later it would
+ honor a hide_on_delete flag - though that isn't there yet.
+ Set border width on the vbox to 2, so we get some padding.
+ Use a button box for the action area.
+ (gtk_dialog_key_press): synthesize a delete event if Esc
+ is pressed and the GtkWidget key press handler didn't
+ handle the escape key.
+ (gtk_dialog_new_with_buttons): new function creates a dialog
+ with some default buttons in it.
+ (gtk_dialog_add_action_widget): add an activatable widget
+ as a button in the dialog - you can also add a non-activatable
+ widget by accessing the action area directly.
+ (gtk_dialog_add_button): add a simple button - stock ID or
+ label - to the action area
+ (gtk_dialog_response): emit response signal
+ (gtk_dialog_run): block waiting for the dialog, return
+ the response. Override normal delete_event behavior, so that
+ delete_event does nothing inside gtk_dialog_run().
+
+ * gtk/gtkdialog.h, gtk/gtkdialog.c: Add "response" signal
+ emitted when an action widget is clicked or the dialog gets
+ delete_event
+
+ * gtk/gtk.h: add gtkmessagedialog.h
+
+ * gtk/Makefile.am: add gtkmessagedialog.[hc]
+
2000-10-18 Havoc Pennington <hp@redhat.com>
* gtk/gtktextiter.c (gtk_text_iter_forward_to_newline): Fix a bug
+2000-10-04 Havoc Pennington <hp@redhat.com>
+
+ * gtk/testgtk.c (create_buttons): create some stock buttons
+ with the default accel group
+ (create_image): test some new GtkImage features
+ (make_message_dialog): test GtkMessageDialog
+ (create_modal_window): fix someone's bizzarro indentation
+
+ * gtk/gtkwindow.h, gtk/gtkwindow.c: Implement
+ GTK_WIN_POS_CENTER_ON_PARENT.
+ Add "destroy with parent" setting, which means the window goes
+ away with its transient parent.
+ (gtk_window_get_default_accel_group): get the default accel group
+ for the window.
+ (gtk_window_set_destroy_with_parent): set/unset destroy with
+ parent flag
+ (gtk_window_read_rcfiles): invalidate icon set caches
+ after reloading rcfiles
+
+ * gtk/gtkenums.h (GtkWindowPosition): add
+ GTK_WIN_POS_CENTER_ON_PARENT, which centers a dialog
+ on its parent window when the dialog is mapped for the first time.
+
+ * gtk/gtkmessagedialog.h, gtk/gtkmessagedialog.c: Add
+ a simple message dialog class
+
+ * gtk/gtkdialog.c (gtk_dialog_init): Connect delete event
+ handler to emit response signal, and maybe later it would
+ honor a hide_on_delete flag - though that isn't there yet.
+ Set border width on the vbox to 2, so we get some padding.
+ Use a button box for the action area.
+ (gtk_dialog_key_press): synthesize a delete event if Esc
+ is pressed and the GtkWidget key press handler didn't
+ handle the escape key.
+ (gtk_dialog_new_with_buttons): new function creates a dialog
+ with some default buttons in it.
+ (gtk_dialog_add_action_widget): add an activatable widget
+ as a button in the dialog - you can also add a non-activatable
+ widget by accessing the action area directly.
+ (gtk_dialog_add_button): add a simple button - stock ID or
+ label - to the action area
+ (gtk_dialog_response): emit response signal
+ (gtk_dialog_run): block waiting for the dialog, return
+ the response. Override normal delete_event behavior, so that
+ delete_event does nothing inside gtk_dialog_run().
+
+ * gtk/gtkdialog.h, gtk/gtkdialog.c: Add "response" signal
+ emitted when an action widget is clicked or the dialog gets
+ delete_event
+
+ * gtk/gtk.h: add gtkmessagedialog.h
+
+ * gtk/Makefile.am: add gtkmessagedialog.[hc]
+
2000-10-18 Havoc Pennington <hp@redhat.com>
* gtk/gtktextiter.c (gtk_text_iter_forward_to_newline): Fix a bug
+2000-10-04 Havoc Pennington <hp@redhat.com>
+
+ * gtk/testgtk.c (create_buttons): create some stock buttons
+ with the default accel group
+ (create_image): test some new GtkImage features
+ (make_message_dialog): test GtkMessageDialog
+ (create_modal_window): fix someone's bizzarro indentation
+
+ * gtk/gtkwindow.h, gtk/gtkwindow.c: Implement
+ GTK_WIN_POS_CENTER_ON_PARENT.
+ Add "destroy with parent" setting, which means the window goes
+ away with its transient parent.
+ (gtk_window_get_default_accel_group): get the default accel group
+ for the window.
+ (gtk_window_set_destroy_with_parent): set/unset destroy with
+ parent flag
+ (gtk_window_read_rcfiles): invalidate icon set caches
+ after reloading rcfiles
+
+ * gtk/gtkenums.h (GtkWindowPosition): add
+ GTK_WIN_POS_CENTER_ON_PARENT, which centers a dialog
+ on its parent window when the dialog is mapped for the first time.
+
+ * gtk/gtkmessagedialog.h, gtk/gtkmessagedialog.c: Add
+ a simple message dialog class
+
+ * gtk/gtkdialog.c (gtk_dialog_init): Connect delete event
+ handler to emit response signal, and maybe later it would
+ honor a hide_on_delete flag - though that isn't there yet.
+ Set border width on the vbox to 2, so we get some padding.
+ Use a button box for the action area.
+ (gtk_dialog_key_press): synthesize a delete event if Esc
+ is pressed and the GtkWidget key press handler didn't
+ handle the escape key.
+ (gtk_dialog_new_with_buttons): new function creates a dialog
+ with some default buttons in it.
+ (gtk_dialog_add_action_widget): add an activatable widget
+ as a button in the dialog - you can also add a non-activatable
+ widget by accessing the action area directly.
+ (gtk_dialog_add_button): add a simple button - stock ID or
+ label - to the action area
+ (gtk_dialog_response): emit response signal
+ (gtk_dialog_run): block waiting for the dialog, return
+ the response. Override normal delete_event behavior, so that
+ delete_event does nothing inside gtk_dialog_run().
+
+ * gtk/gtkdialog.h, gtk/gtkdialog.c: Add "response" signal
+ emitted when an action widget is clicked or the dialog gets
+ delete_event
+
+ * gtk/gtk.h: add gtkmessagedialog.h
+
+ * gtk/Makefile.am: add gtkmessagedialog.[hc]
+
2000-10-18 Havoc Pennington <hp@redhat.com>
* gtk/gtktextiter.c (gtk_text_iter_forward_to_newline): Fix a bug
+2000-10-04 Havoc Pennington <hp@redhat.com>
+
+ * gtk/testgtk.c (create_buttons): create some stock buttons
+ with the default accel group
+ (create_image): test some new GtkImage features
+ (make_message_dialog): test GtkMessageDialog
+ (create_modal_window): fix someone's bizzarro indentation
+
+ * gtk/gtkwindow.h, gtk/gtkwindow.c: Implement
+ GTK_WIN_POS_CENTER_ON_PARENT.
+ Add "destroy with parent" setting, which means the window goes
+ away with its transient parent.
+ (gtk_window_get_default_accel_group): get the default accel group
+ for the window.
+ (gtk_window_set_destroy_with_parent): set/unset destroy with
+ parent flag
+ (gtk_window_read_rcfiles): invalidate icon set caches
+ after reloading rcfiles
+
+ * gtk/gtkenums.h (GtkWindowPosition): add
+ GTK_WIN_POS_CENTER_ON_PARENT, which centers a dialog
+ on its parent window when the dialog is mapped for the first time.
+
+ * gtk/gtkmessagedialog.h, gtk/gtkmessagedialog.c: Add
+ a simple message dialog class
+
+ * gtk/gtkdialog.c (gtk_dialog_init): Connect delete event
+ handler to emit response signal, and maybe later it would
+ honor a hide_on_delete flag - though that isn't there yet.
+ Set border width on the vbox to 2, so we get some padding.
+ Use a button box for the action area.
+ (gtk_dialog_key_press): synthesize a delete event if Esc
+ is pressed and the GtkWidget key press handler didn't
+ handle the escape key.
+ (gtk_dialog_new_with_buttons): new function creates a dialog
+ with some default buttons in it.
+ (gtk_dialog_add_action_widget): add an activatable widget
+ as a button in the dialog - you can also add a non-activatable
+ widget by accessing the action area directly.
+ (gtk_dialog_add_button): add a simple button - stock ID or
+ label - to the action area
+ (gtk_dialog_response): emit response signal
+ (gtk_dialog_run): block waiting for the dialog, return
+ the response. Override normal delete_event behavior, so that
+ delete_event does nothing inside gtk_dialog_run().
+
+ * gtk/gtkdialog.h, gtk/gtkdialog.c: Add "response" signal
+ emitted when an action widget is clicked or the dialog gets
+ delete_event
+
+ * gtk/gtk.h: add gtkmessagedialog.h
+
+ * gtk/Makefile.am: add gtkmessagedialog.[hc]
+
2000-10-18 Havoc Pennington <hp@redhat.com>
* gtk/gtktextiter.c (gtk_text_iter_forward_to_newline): Fix a bug
+2000-10-04 Havoc Pennington <hp@redhat.com>
+
+ * gtk/testgtk.c (create_buttons): create some stock buttons
+ with the default accel group
+ (create_image): test some new GtkImage features
+ (make_message_dialog): test GtkMessageDialog
+ (create_modal_window): fix someone's bizzarro indentation
+
+ * gtk/gtkwindow.h, gtk/gtkwindow.c: Implement
+ GTK_WIN_POS_CENTER_ON_PARENT.
+ Add "destroy with parent" setting, which means the window goes
+ away with its transient parent.
+ (gtk_window_get_default_accel_group): get the default accel group
+ for the window.
+ (gtk_window_set_destroy_with_parent): set/unset destroy with
+ parent flag
+ (gtk_window_read_rcfiles): invalidate icon set caches
+ after reloading rcfiles
+
+ * gtk/gtkenums.h (GtkWindowPosition): add
+ GTK_WIN_POS_CENTER_ON_PARENT, which centers a dialog
+ on its parent window when the dialog is mapped for the first time.
+
+ * gtk/gtkmessagedialog.h, gtk/gtkmessagedialog.c: Add
+ a simple message dialog class
+
+ * gtk/gtkdialog.c (gtk_dialog_init): Connect delete event
+ handler to emit response signal, and maybe later it would
+ honor a hide_on_delete flag - though that isn't there yet.
+ Set border width on the vbox to 2, so we get some padding.
+ Use a button box for the action area.
+ (gtk_dialog_key_press): synthesize a delete event if Esc
+ is pressed and the GtkWidget key press handler didn't
+ handle the escape key.
+ (gtk_dialog_new_with_buttons): new function creates a dialog
+ with some default buttons in it.
+ (gtk_dialog_add_action_widget): add an activatable widget
+ as a button in the dialog - you can also add a non-activatable
+ widget by accessing the action area directly.
+ (gtk_dialog_add_button): add a simple button - stock ID or
+ label - to the action area
+ (gtk_dialog_response): emit response signal
+ (gtk_dialog_run): block waiting for the dialog, return
+ the response. Override normal delete_event behavior, so that
+ delete_event does nothing inside gtk_dialog_run().
+
+ * gtk/gtkdialog.h, gtk/gtkdialog.c: Add "response" signal
+ emitted when an action widget is clicked or the dialog gets
+ delete_event
+
+ * gtk/gtk.h: add gtkmessagedialog.h
+
+ * gtk/Makefile.am: add gtkmessagedialog.[hc]
+
2000-10-18 Havoc Pennington <hp@redhat.com>
* gtk/gtktextiter.c (gtk_text_iter_forward_to_newline): Fix a bug
+2000-10-04 Havoc Pennington <hp@redhat.com>
+
+ * gtk/testgtk.c (create_buttons): create some stock buttons
+ with the default accel group
+ (create_image): test some new GtkImage features
+ (make_message_dialog): test GtkMessageDialog
+ (create_modal_window): fix someone's bizzarro indentation
+
+ * gtk/gtkwindow.h, gtk/gtkwindow.c: Implement
+ GTK_WIN_POS_CENTER_ON_PARENT.
+ Add "destroy with parent" setting, which means the window goes
+ away with its transient parent.
+ (gtk_window_get_default_accel_group): get the default accel group
+ for the window.
+ (gtk_window_set_destroy_with_parent): set/unset destroy with
+ parent flag
+ (gtk_window_read_rcfiles): invalidate icon set caches
+ after reloading rcfiles
+
+ * gtk/gtkenums.h (GtkWindowPosition): add
+ GTK_WIN_POS_CENTER_ON_PARENT, which centers a dialog
+ on its parent window when the dialog is mapped for the first time.
+
+ * gtk/gtkmessagedialog.h, gtk/gtkmessagedialog.c: Add
+ a simple message dialog class
+
+ * gtk/gtkdialog.c (gtk_dialog_init): Connect delete event
+ handler to emit response signal, and maybe later it would
+ honor a hide_on_delete flag - though that isn't there yet.
+ Set border width on the vbox to 2, so we get some padding.
+ Use a button box for the action area.
+ (gtk_dialog_key_press): synthesize a delete event if Esc
+ is pressed and the GtkWidget key press handler didn't
+ handle the escape key.
+ (gtk_dialog_new_with_buttons): new function creates a dialog
+ with some default buttons in it.
+ (gtk_dialog_add_action_widget): add an activatable widget
+ as a button in the dialog - you can also add a non-activatable
+ widget by accessing the action area directly.
+ (gtk_dialog_add_button): add a simple button - stock ID or
+ label - to the action area
+ (gtk_dialog_response): emit response signal
+ (gtk_dialog_run): block waiting for the dialog, return
+ the response. Override normal delete_event behavior, so that
+ delete_event does nothing inside gtk_dialog_run().
+
+ * gtk/gtkdialog.h, gtk/gtkdialog.c: Add "response" signal
+ emitted when an action widget is clicked or the dialog gets
+ delete_event
+
+ * gtk/gtk.h: add gtkmessagedialog.h
+
+ * gtk/Makefile.am: add gtkmessagedialog.[hc]
+
2000-10-18 Havoc Pennington <hp@redhat.com>
* gtk/gtktextiter.c (gtk_text_iter_forward_to_newline): Fix a bug
+2000-10-20 Havoc Pennington <hp@redhat.com>
+
+ * gtk/gtk-sections.txt: Add dialog docs
+
2000-10-18 Havoc Pennington <hp@redhat.com>
* gtk/gtk-sections.txt: Some updates
+<!-- ##### SECTION ./tmpl/from-drawables.sgml:Title ##### -->
+Drawables to Pixbufs
+
+
<!-- ##### USER_FUNCTION GdkPixbufLastUnref ##### -->
<para>
A function of this type can be used to override the default
@pixbuf: The pixbuf that is losing its last reference.
@data: User closure data.
-<!-- ##### SECTION ./tmpl/from-drawables.sgml:Title ##### -->
-Drawables to Pixbufs
-
-
<!-- ##### ARG GnomeCanvasPixbuf:height_pixels ##### -->
<para>
</para>
-<!-- ##### SECTION ./tmpl/xlib-from-drawables.sgml:See_Also ##### -->
-<para>
-
-</para>
-
-
<!-- ##### SECTION ./tmpl/from-drawables.sgml:See_Also ##### -->
<para>
gdk_image_get().
</para>
+<!-- ##### SECTION ./tmpl/xlib-from-drawables.sgml:See_Also ##### -->
+<para>
+
+</para>
+
+
<!-- ##### STRUCT GdkPixbufAnimationClass ##### -->
<para>
</para>
+<!-- ##### SECTION ./tmpl/gdk-pixbuf-io.sgml:Long_Description ##### -->
+<para>
+
+</para>
+
+
<!-- ##### SECTION ./tmpl/gnome-canvas-pixbuf.sgml:Long_Description ##### -->
<para>
This canvas item displays #GdkPixbuf images. It handles full
</refsect2>
-<!-- ##### SECTION ./tmpl/gdk-pixbuf-io.sgml:Long_Description ##### -->
-<para>
-
-</para>
-
-
<!-- ##### SECTION ./tmpl/xlib-rendering.sgml:Title ##### -->
Xlib Rendering
<FILE>gtkdialog</FILE>
GtkDialog
<TITLE>GtkDialog</TITLE>
-GtkDialogButton
+GtkDialogFlags
gtk_dialog_new
+gtk_dialog_new_with_buttons
+gtk_dialog_run
+gtk_dialog_response
+gtk_dialog_add_button
+gtk_dialog_add_buttons
+gtk_dialog_add_action_widget
<SUBSECTION Standard>
GTK_DIALOG
GTK_IS_DIALOG
GTK_MENU_SHELL_GET_CLASS
</SECTION>
+<SECTION>
+<FILE>gtkmessagedialog</FILE>
+GtkMessageDialog
+<TITLE>GtkMessageDialog</TITLE>
+GtkMessageType
+GtkButtonsType
+gtk_message_dialog_new
+<SUBSECTION Standard>
+GTK_MESSAGE_DIALOG
+GTK_IS_MESSAGE_DIALOG
+GTK_TYPE_MESSAGE_DIALOG
+gtk_message_dialog_get_type
+GTK_MESSAGE_DIALOG_CLASS
+GTK_IS_MESSAGE_DIALOG_CLASS
+GTK_MESSAGE_DIALOG_GET_CLASS
+</SECTION>
+
<SECTION>
<FILE>gtkmisc</FILE>
<TITLE>GtkMisc</TITLE>
gtk_window_set_geometry_hints
gtk_window_set_position
gtk_window_set_transient_for
+gtk_window_set_destroy_with_parent
gtk_window_list_toplevels
<SUBSECTION Standard>
GTK_WINDOW
@object_size:
@class_size:
-<!-- ##### MACRO gtk_widget_pop_visual ##### -->
+<!-- ##### FUNCTION gtk_text_buffer_get_clipboard_contents ##### -->
<para>
</para>
-@v:
+@buffer:
+@Returns:
-<!-- ##### FUNCTION gtk_text_buffer_get_clipboard_contents ##### -->
+<!-- ##### MACRO gtk_widget_pop_visual ##### -->
<para>
</para>
-@buffer:
-@Returns:
+@v:
<!-- ##### FUNCTION gtk_marshal_NONE__C_CALLBACK ##### -->
<para>
@textview: the object which received the signal.
+<!-- ##### STRUCT GtkDialogButton ##### -->
+<para>
+Deprecated.
+</para>
+
+
<!-- ##### FUNCTION gtk_marshal_BOOL__POINTER ##### -->
<para>
@func_data:
@args:
-<!-- ##### FUNCTION gtk_paned_compute_position ##### -->
-<para>
-Internal function used by #GtkHPaned and #GtkVPaned
-</para>
-
-@paned:
-@allocation:
-@child1_req:
-@child2_req:
-
<!-- ##### FUNCTION gtk_marshal_NONE__INT_FLOAT_BOOL ##### -->
<para>
@func_data:
@args:
+<!-- ##### FUNCTION gtk_paned_compute_position ##### -->
+<para>
+Internal function used by #GtkHPaned and #GtkVPaned
+</para>
+
+@paned:
+@allocation:
+@child1_req:
+@child2_req:
+
<!-- ##### MACRO gtk_marshal_NONE__POINTER_STRING_STRING ##### -->
<para>
@values: GtkFlagValue*
@Returns:
-<!-- ##### SIGNAL GtkTextView::scroll-text ##### -->
+<!-- ##### FUNCTION gtk_selection_clear_targets ##### -->
<para>
</para>
-@textview: the object which received the signal.
-@arg1:
+@widget:
+@selection:
-<!-- ##### FUNCTION gtk_selection_clear_targets ##### -->
+<!-- ##### SIGNAL GtkTextView::scroll-text ##### -->
<para>
</para>
-@widget:
-@selection:
+@textview: the object which received the signal.
+@arg1:
<!-- ##### ENUM GtkPrivateFlags ##### -->
<para>
</para>
@clipboard:
-@Returns:
-<!--
+@Returns: <!--
Local variables:
mode: sgml
sgml-parent-document: ("../gtk-docs.sgml" "book" "refsect2" "")
@func_data:
@args:
-<!-- ##### USER_FUNCTION GtkMenuCallback ##### -->
-<para>
-
-</para>
-
-@widget:
-@user_data:
-
<!-- ##### FUNCTION gtk_type_check_object_cast ##### -->
<para>
Given a pointer to a GtkTypeObject @type_object, and a GtkType @cast_type,
@cast_type: GtkType
@Returns: the same GtkTypeObject* as @type_object
+<!-- ##### USER_FUNCTION GtkMenuCallback ##### -->
+<para>
+
+</para>
+
+@widget:
+@user_data:
+
<!-- ##### FUNCTION gtk_themes_exit ##### -->
<para>
@user_data_or_owner: the @user_data argument passed to gtk_clipboard_set_with_data(), or
the @owner argument passed to gtk_clipboard_set_owner()
-<!-- ##### SECTION ./tmpl/gtkmenufactory.sgml:Long_Description ##### -->
+<!-- ##### MACRO gtk_marshal_NONE__OBJECT ##### -->
<para>
</para>
-<!-- ##### MACRO gtk_marshal_NONE__OBJECT ##### -->
+<!-- ##### SECTION ./tmpl/gtkmenufactory.sgml:Long_Description ##### -->
<para>
</para>
</para>
-<!-- ##### MACRO gtk_widget_push_visual ##### -->
+<!-- ##### FUNCTION gtk_container_register_toplevel ##### -->
<para>
</para>
-@v:
-@visual:
+@container:
<!-- ##### MACRO gtk_marshal_ENUM__ENUM ##### -->
<para>
</para>
-<!-- ##### FUNCTION gtk_container_register_toplevel ##### -->
+<!-- ##### MACRO gtk_widget_push_visual ##### -->
<para>
</para>
-@container:
+@v:
+@visual:
<!-- ##### SECTION ./tmpl/gtkimcontextsimple.sgml:Title ##### -->
GtkIMContextSimple
create popup windows.
<!-- ##### SECTION Long_Description ##### -->
+
<para>
Dialog boxes are a convenient way to prompt the user for a small amount of
-input, eg. to display
-a message, ask a question, or anything else that does not require extensive
-effort on the user's part.
+input, eg. to display a message, ask a question, or anything else that does not
+require extensive effort on the user's part.
</para>
+
<para>
Gtk+ treats a dialog as a window split horizontally. The top section is a
#GtkVBox, and is where widgets such as a #GtkLabel or a #GtkEntry should be
-packed. The second area is known as the <structfield>action_area</structfield>. This is generally used
-for packing buttons into the dialog which may perform functions such as cancel, ok, or apply. The two
-areas are separated by a #GtkHSeparator.
+packed. The second area is known as the
+<structfield>action_area</structfield>. This is generally used for packing
+buttons into the dialog which may perform functions such as cancel, ok, or
+apply. The two areas are separated by a #GtkHSeparator.
</para>
+
<para>
-#GtkDialog boxes are created with a call to gtk_dialog_new().
+#GtkDialog boxes are created with a call to gtk_dialog_new() or
+gtk_dialog_new_with_buttons(). gtk_dialog_new_with_buttons() is recommended; it
+allows you to set the dialog title, some convenient flags, and add simple
+buttons.
</para>
+
<para>
If 'dialog' is a newly created dialog, the two primary areas of the window
can be accessed as GTK_DIALOG(dialog)->vbox and GTK_DIALOG(dialog)->action_area,
as can be seen from the example, below.
</para>
+
+<para>
+A 'modal' dialog (that is, one which freezes the rest of the application from
+user input), can be created by calling gtk_window_set_modal() on the dialog. Use
+the GTK_WINDOW() macro to cast the widget returned from gtk_dialog_new() into a
+#GtkWindow. When using gtk_dialog_new_with_buttons() you can also pass the
+GTK_DIALOG_MODAL flag to make a dialog modal.
+</para>
+
<para>
-A 'modal' dialog (that is, one which freezes the rest of the application
-from user input), can be created by calling gtk_window_set_modal() on the dialog. Use the
-GTK_WINDOW() macro to cast the widget returned from gtk_dialog_new() into a
-#GtkWindow.
+If you add buttons to #GtkDialog using gtk_dialog_new_with_buttons(),
+gtk_dialog_add_button(), gtk_dialog_add_buttons(), or
+gtk_dialog_add_action_widget(), clicking the button will emit a signal called
+"response" with a response ID that you specified. GTK+ will never assign a
+meaning to positive response IDs; these are entirely user-defined. But for
+convenience, you can use the response IDs in the #GtkResponseType enumeration
+(these all have values less than zero). If a dialog receives a delete event, the
+"response" signal will be emitted with a response ID of GTK_RESPONSE_NONE.
</para>
+
+
<para>
+If you want to block waiting for a dialog to return before returning control
+flow to your code, you can call gtk_dialog_run(). This function enters a
+recursive main loop and waits for the user to respond to the dialog, returning the
+response ID corresponding to the button the user clicked.
+</para>
+
+<para>
+For the simple dialog in the following example, in reality you'd probably use
+#GtkMessageDialog to save yourself some effort. But you'd need to create the
+dialog contents manually if you had more than a simple message in the dialog.
<example>
-<title>Using a #GtkDialog to keep the user informed.</title>
+<title>Simple #GtkDialog usage.</title>
<programlisting>
/* Function to open a dialog box displaying the message provided. */
void quick_message(#gchar *message) {
- #GtkWidget *dialog, *label, *okay_button;
+ #GtkWidget *dialog, *label;
/* Create the widgets */
- dialog = gtk_dialog_new();
+ dialog = gtk_dialog_new_with_buttons ("Message",
+ main_application_window,
+ GTK_DIALOG_DESTROY_WITH_PARENT,
+ GTK_STOCK_BUTTON_OK,
+ GTK_RESPONSE_NONE,
+ NULL);
label = gtk_label_new (message);
- okay_button = gtk_button_new_with_label("Okay");
- /* Ensure that the dialog box is destroyed when the user clicks ok. */
+ /* Ensure that the dialog box is destroyed when the user responds. */
- gtk_signal_connect_object (GTK_OBJECT (okay_button), "clicked",
- GTK_SIGNAL_FUNC (gtk_widget_destroy), dialog);
- gtk_container_add (GTK_CONTAINER (GTK_DIALOG(dialog)->action_area),
- okay_button);
+ gtk_signal_connect_object (GTK_OBJECT (dialog), "response",
+ GTK_SIGNAL_FUNC (gtk_widget_destroy),
+ GTK_OBJECT (dialog));
/* Add the label, and show everything we've added to the dialog. */
</para>
-<!-- ##### STRUCT GtkDialogButton ##### -->
+<!-- ##### ENUM GtkDialogFlags ##### -->
<para>
-Deprecated.
+
</para>
+@GTK_DIALOG_MODAL:
+@GTK_DIALOG_DESTROY_WITH_PARENT:
<!-- ##### FUNCTION gtk_dialog_new ##### -->
<para>
@Returns: a #GtkWidget - the newly created dialog box.
+<!-- ##### FUNCTION gtk_dialog_new_with_buttons ##### -->
+<para>
+
+</para>
+
+@title:
+@parent:
+@flags:
+@first_button_text:
+@Varargs:
+@Returns:
+
+
+<!-- ##### FUNCTION gtk_dialog_run ##### -->
+<para>
+
+</para>
+
+@dialog:
+@Returns:
+
+
+<!-- ##### FUNCTION gtk_dialog_response ##### -->
+<para>
+
+</para>
+
+@dialog:
+@response_id:
+
+
+<!-- ##### FUNCTION gtk_dialog_add_button ##### -->
+<para>
+
+</para>
+
+@dialog:
+@button_text:
+@response_id:
+
+
+<!-- ##### FUNCTION gtk_dialog_add_buttons ##### -->
+<para>
+
+</para>
+
+@dialog:
+@first_button_text:
+@Varargs:
+
+
+<!-- ##### FUNCTION gtk_dialog_add_action_widget ##### -->
+<para>
+
+</para>
+
+@dialog:
+@child:
+@response_id:
+<!-- # Unused Parameters # -->
+@widget:
+
+
+<!-- ##### SIGNAL GtkDialog::response ##### -->
+<para>
+Emitted when an action widget is clicked, the dialog receives a delete event, or
+the application programmer calls gtk_dialog_response(). On a delete event, the
+response ID is GTK_RESPONSE_NONE. Otherwise, it depends on which action widget
+was clicked.
+</para>
+
+@dialog: the object which received the signal.
+@arg1: the response ID
+
@GTK_WIN_POS_CENTER: Windows should be placed in the center of the screen.
@GTK_WIN_POS_MOUSE: Windows should be placed at the current mouse position.
@GTK_WIN_POS_CENTER_ALWAYS:
+@GTK_WIN_POS_CENTER_ON_PARENT:
<!-- ##### ENUM GtkWindowType ##### -->
<para>
</listitem>
</varlistentry>
<varlistentry>
- <term><literal>stock[<replaceable>"stock-id"</replaceable>]</literal> = { <replaceable>icon source specifications</replaceable> }</literal></term>
+ <term><literal>stock[<replaceable>"stock-id"</replaceable>] = { <replaceable>icon source specifications</replaceable> }</literal></term>
<listitem>
<para>
Defines the icon for a stock item.
<listitem>
<para>
A color used for the background of widgets that have
- been set insenstivie with gtk_widget_set_senstive()
+ been set insensitive with gtk_widget_set_sensitive()
</para>
</listitem>
</varlistentry>
@mark:
+<!-- ##### FUNCTION gtk_text_mark_get_deleted ##### -->
+<para>
+
+</para>
+
+@mark:
+@Returns:
+
+
@parent:
+<!-- ##### FUNCTION gtk_window_set_destroy_with_parent ##### -->
+<para>
+
+</para>
+
+@window:
+@setting:
+
+
<!-- ##### FUNCTION gtk_window_list_toplevels ##### -->
<para>
</para>
+<!-- ##### ARG GtkWindow:destroy_with_parent ##### -->
+<para>
+
+</para>
+
gtkmenufactory.h \
gtkmenuitem.h \
gtkmenushell.h \
+ gtkmessagedialog.h \
gtkmisc.h \
gtkmodelsimple.h \
gtknotebook.h \
gtkmenufactory.c \
gtkmenuitem.c \
gtkmenushell.c \
+ gtkmessagedialog.c \
gtkmisc.c \
gtkmodelsimple.c \
gtknotebook.c \
#include <gtk/gtkmenufactory.h>
#include <gtk/gtkmenuitem.h>
#include <gtk/gtkmenushell.h>
+#include <gtk/gtkmessagedialog.h>
#include <gtk/gtkmisc.h>
#include <gtk/gtkmodelsimple.h>
#include <gtk/gtknotebook.h>
#include "gtkbutton.h"
#include "gtkdialog.h"
-#include "gtkhbox.h"
+#include "gtkhbbox.h"
#include "gtkhseparator.h"
#include "gtkvbox.h"
-
+#include "gtksignal.h"
+#include "gdkkeysyms.h"
+#include "gtkmain.h"
static void gtk_dialog_class_init (GtkDialogClass *klass);
static void gtk_dialog_init (GtkDialog *dialog);
+static gint gtk_dialog_key_press (GtkWidget *widget,
+ GdkEventKey *key);
+
+static void gtk_dialog_add_buttons_valist (GtkDialog *dialog,
+ const gchar *first_button_text,
+ va_list args);
+
+static gint gtk_dialog_delete_event_handler (GtkWidget *widget,
+ GdkEventAny *event,
+ gpointer user_data);
+
+
+enum {
+ RESPONSE,
+ LAST_SIGNAL
+};
+static gpointer parent_class;
+static guint dialog_signals[LAST_SIGNAL];
GtkType
gtk_dialog_get_type (void)
static void
gtk_dialog_class_init (GtkDialogClass *class)
{
+ GtkObjectClass *object_class;
+ GtkWidgetClass *widget_class;
+
+ object_class = (GtkObjectClass*) class;
+ widget_class = (GtkWidgetClass*) class;
+
+ parent_class = g_type_class_peek_parent (class);
+
+ dialog_signals[RESPONSE] =
+ gtk_signal_new ("response",
+ GTK_RUN_LAST,
+ GTK_CLASS_TYPE (object_class),
+ GTK_SIGNAL_OFFSET (GtkDialogClass, response),
+ gtk_marshal_NONE__INT,
+ GTK_TYPE_NONE, 1,
+ GTK_TYPE_INT);
+
+ gtk_object_class_add_signals (object_class, dialog_signals, LAST_SIGNAL);
+
+ widget_class->key_press_event = gtk_dialog_key_press;
}
static void
{
GtkWidget *separator;
+ /* To avoid breaking old code that prevents destroy on delete event
+ * by connecting a handler, we have to have the FIRST signal
+ * connection on the dialog.
+ */
+ gtk_signal_connect (GTK_OBJECT (dialog),
+ "delete_event",
+ GTK_SIGNAL_FUNC (gtk_dialog_delete_event_handler),
+ NULL);
+
dialog->vbox = gtk_vbox_new (FALSE, 0);
+
+ gtk_container_set_border_width (GTK_CONTAINER (dialog->vbox), 2);
+
gtk_container_add (GTK_CONTAINER (dialog), dialog->vbox);
gtk_widget_show (dialog->vbox);
- dialog->action_area = gtk_hbox_new (TRUE, 5);
+ dialog->action_area = gtk_hbutton_box_new ();
+
+ gtk_button_box_set_layout (GTK_BUTTON_BOX (dialog->action_area),
+ GTK_BUTTONBOX_SPREAD);
+
gtk_container_set_border_width (GTK_CONTAINER (dialog->action_area), 10);
- gtk_box_pack_end (GTK_BOX (dialog->vbox), dialog->action_area, FALSE, TRUE, 0);
+ gtk_box_pack_end (GTK_BOX (dialog->vbox), dialog->action_area,
+ FALSE, TRUE, 0);
gtk_widget_show (dialog->action_area);
separator = gtk_hseparator_new ();
gtk_widget_show (separator);
}
+static gint
+gtk_dialog_delete_event_handler (GtkWidget *widget,
+ GdkEventAny *event,
+ gpointer user_data)
+{
+ /* emit response signal */
+ gtk_dialog_response (GTK_DIALOG (widget), GTK_RESPONSE_NONE);
+
+ /* Do the destroy by default */
+ return FALSE;
+}
+
+static gint
+gtk_dialog_key_press (GtkWidget *widget,
+ GdkEventKey *key)
+{
+ GdkEventAny event;
+
+ event.type = GDK_DELETE;
+ event.window = widget->window;
+ event.send_event = TRUE;
+
+ if (GTK_WIDGET_CLASS (parent_class)->key_press_event (widget, key))
+ return TRUE;
+
+ if (key->keyval != GDK_Escape)
+ return FALSE;
+
+ /* Synthesize delete_event on key press. */
+ g_object_ref (G_OBJECT (event.window));
+
+ gtk_main_do_event ((GdkEvent*)&event);
+
+ g_object_unref (G_OBJECT (event.window));
+
+ return TRUE;
+}
+
GtkWidget*
gtk_dialog_new (void)
{
return GTK_WIDGET (gtk_type_new (GTK_TYPE_DIALOG));
}
+
+static GtkWidget*
+gtk_dialog_new_empty (const gchar *title,
+ GtkWindow *parent,
+ GtkDialogFlags flags)
+{
+ GtkDialog *dialog;
+
+ dialog = GTK_DIALOG (g_object_new (GTK_TYPE_DIALOG, NULL));
+
+ if (title)
+ gtk_window_set_title (GTK_WINDOW (dialog), title);
+
+ if (parent)
+ gtk_window_set_transient_for (GTK_WINDOW (dialog), parent);
+
+ if (flags & GTK_DIALOG_MODAL)
+ gtk_window_set_modal (GTK_WINDOW (dialog), TRUE);
+
+ if (flags & GTK_DIALOG_DESTROY_WITH_PARENT)
+ gtk_window_set_destroy_with_parent (GTK_WINDOW (dialog), TRUE);
+
+ return GTK_WIDGET (dialog);
+}
+
+/**
+ * gtk_dialog_new_with_buttons:
+ * @title: Title of the dialog, or NULL
+ * @parent: Transient parent of the dialog, or NULL
+ * @flags: from #GtkDialogFlags
+ * @first_button_text: stock ID or text to go in first button, or NULL
+ * @Varargs: response ID for first button, then additional buttons, ending with NULL
+ *
+ * Creates a new #GtkDialog with title @title (or NULL for the default
+ * title; see gtk_window_set_title()) and transient parent @parent (or
+ * NULL for none; see gtk_window_set_transient_for()). The @flags
+ * argument can be used to make the dialog modal (GTK_DIALOG_MODAL)
+ * and/or to have it destroyed along with its transient parent
+ * (GTK_DIALOG_DESTROY_WITH_PARENT). After @flags, button
+ * text/response ID pairs should be listed, with a NULL pointer ending
+ * the list. Button text can be either a stock ID such as
+ * GTK_STOCK_BUTTON_OK, or some arbitrary text. A response ID can be
+ * any positive number, or one of the values in the #GtkResponseType
+ * enumeration. If the user clicks one of these dialog buttons,
+ * #GtkDialog will emit the "response" signal with the corresponding
+ * response ID. If a #GtkDialog receives the "delete_event" signal, it
+ * will emit "response" with a response ID of GTK_RESPONSE_NONE.
+ * However, destroying a dialog does not emit the "response" signal;
+ * so be careful relying on "response" when using
+ * the GTK_DIALOG_DESTROY_WITH_PARENT flag. Buttons are from left to right,
+ * so the first button in the list will be the leftmost button in the dialog.
+ *
+ * Here's a simple example:
+ * <programlisting>
+ * GtkWidget *dialog = gtk_dialog_new_with_buttons ("My dialog",
+ * main_app_window,
+ * GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,
+ * GTK_STOCK_BUTTON_OK,
+ * GTK_RESPONSE_ACCEPT,
+ * GTK_STOCK_BUTTON_CANCEL,
+ * GTK_RESPONSE_NONE,
+ * NULL);
+ * </programlisting>
+ *
+ * Return value: a new #GtkDialog
+ **/
+GtkWidget*
+gtk_dialog_new_with_buttons (const gchar *title,
+ GtkWindow *parent,
+ GtkDialogFlags flags,
+ const gchar *first_button_text,
+ ...)
+{
+ GtkDialog *dialog;
+ va_list args;
+
+ dialog = GTK_DIALOG (gtk_dialog_new_empty (title, parent, flags));
+
+ va_start (args, first_button_text);
+
+ gtk_dialog_add_buttons_valist (dialog,
+ first_button_text,
+ args);
+
+ va_end (args);
+
+ return GTK_WIDGET (dialog);
+}
+
+typedef struct _ResponseData ResponseData;
+
+struct _ResponseData
+{
+ gint response_id;
+};
+
+static ResponseData*
+get_response_data (GtkWidget *widget)
+{
+ ResponseData *ad = gtk_object_get_data (GTK_OBJECT (widget),
+ "gtk-dialog-response-data");
+
+ if (ad == NULL)
+ {
+ ad = g_new (ResponseData, 1);
+
+ gtk_object_set_data_full (GTK_OBJECT (widget),
+ "gtk-dialog-response-data",
+ ad,
+ g_free);
+ }
+
+ return ad;
+}
+
+static void
+action_widget_activated (GtkWidget *widget, GtkDialog *dialog)
+{
+ ResponseData *ad;
+ gint response_id;
+
+ g_return_if_fail (GTK_IS_DIALOG (dialog));
+
+ response_id = GTK_RESPONSE_NONE;
+
+ ad = get_response_data (widget);
+
+ g_assert (ad != NULL);
+
+ response_id = ad->response_id;
+
+ gtk_dialog_response (dialog, response_id);
+}
+/**
+ * gtk_dialog_add_action_widget:
+ * @dialog: a #GtkDialog
+ * @child: an activatable widget
+ * @response_id: response ID for @child
+ *
+ * Adds an activatable widget to the action area of a #GtkDialog,
+ * connecting a signal handler that will emit the "response" signal on
+ * the dialog when the widget is activated. The widget is appended to
+ * the end of the dialog's action area. If you want to add a
+ * non-activatable widget, simply pack it into the
+ * <literal>action_area</literal> field of the #GtkDialog struct.
+ *
+ **/
+void
+gtk_dialog_add_action_widget (GtkDialog *dialog,
+ GtkWidget *child,
+ gint response_id)
+{
+ ResponseData *ad;
+
+ g_return_if_fail (GTK_IS_DIALOG (dialog));
+ g_return_if_fail (GTK_IS_WIDGET (child));
+
+ ad = get_response_data (child);
+
+ ad->response_id = response_id;
+
+ if (GTK_WIDGET_GET_CLASS (child)->activate_signal != 0)
+ {
+ const gchar* name =
+ gtk_signal_name (GTK_WIDGET_GET_CLASS (child)->activate_signal);
+
+ gtk_signal_connect_while_alive (GTK_OBJECT (child),
+ name,
+ GTK_SIGNAL_FUNC (action_widget_activated),
+ dialog,
+ GTK_OBJECT (dialog));
+ }
+ else
+ g_warning ("Only 'activatable' widgets can be packed into the action area of a GtkDialog");
+
+ gtk_box_pack_end (GTK_BOX (dialog->action_area),
+ child,
+ FALSE, TRUE, 5);
+}
+
+/**
+ * gtk_dialog_add_button:
+ * @dialog: a #GtkDialog
+ * @button_text: text of button, or stock ID
+ * @response_id: response ID for the button
+ *
+ * Adds a button with the given text (or a stock button, if @button_text is a
+ * stock ID) and sets things up so that clicking the button will emit the
+ * "response" signal with the given @response_id. The button is appended to the
+ * end of the dialog's action area.
+ *
+ **/
+void
+gtk_dialog_add_button (GtkDialog *dialog,
+ const gchar *button_text,
+ gint response_id)
+{
+ GtkWidget *button;
+
+ g_return_if_fail (GTK_IS_DIALOG (dialog));
+ g_return_if_fail (button_text != NULL);
+
+ button = gtk_button_new_stock (button_text,
+ gtk_window_get_default_accel_group (GTK_WINDOW (dialog)));
+
+ gtk_widget_show (button);
+
+ gtk_dialog_add_action_widget (dialog,
+ button,
+ response_id);
+}
+
+static void
+gtk_dialog_add_buttons_valist(GtkDialog *dialog,
+ const gchar *first_button_text,
+ va_list args)
+{
+ const gchar* text;
+ gint response_id;
+
+ if (first_button_text == NULL)
+ return;
+
+ text = first_button_text;
+ response_id = va_arg (args, gint);
+
+ while (text != NULL)
+ {
+ gtk_dialog_add_button (dialog, text, response_id);
+
+ text = va_arg (args, gchar*);
+ if (text == NULL)
+ break;
+ response_id = va_arg (args, int);
+ }
+}
+
+/**
+ * gtk_dialog_add_buttons:
+ * @dialog: a #GtkDialog
+ * @first_button_text: button text or stock ID
+ * @Varargs: response ID for first button, then more text-response_id pairs
+ *
+ * Adds more buttons, same as calling gtk_dialog_add_button()
+ * repeatedly. The variable argument list should be NULL-terminated
+ * as with gtk_dialog_new_with_buttons(). Each button must have both
+ * text and response ID.
+ *
+ **/
+void
+gtk_dialog_add_buttons (GtkDialog *dialog,
+ const gchar *first_button_text,
+ ...)
+{
+
+ va_list args;
+
+ va_start (args, first_button_text);
+
+ gtk_dialog_add_buttons_valist (dialog,
+ first_button_text,
+ args);
+
+ va_end (args);
+}
+
+/**
+ * gtk_dialog_response:
+ * @dialog: a #GtkDialog
+ * @response_id: response ID
+ *
+ * Emits the "response" signal with the given response ID. Used to
+ * indicate that the user has responded to the dialog in some way;
+ * typically either you or gtk_dialog_run() will be monitoring the
+ * "response" signal and take appropriate action.
+ **/
+void
+gtk_dialog_response (GtkDialog *dialog,
+ gint response_id)
+{
+ g_return_if_fail (dialog != NULL);
+ g_return_if_fail (GTK_IS_DIALOG (dialog));
+
+ gtk_signal_emit (GTK_OBJECT (dialog),
+ dialog_signals[RESPONSE],
+ response_id);
+}
+
+typedef struct
+{
+ GtkDialog *dialog;
+ gint response_id;
+ GMainLoop *loop;
+} RunInfo;
+
+static void
+shutdown_loop (RunInfo *ri)
+{
+ if (ri->loop != NULL)
+ {
+ g_main_quit (ri->loop);
+ g_main_destroy (ri->loop);
+ ri->loop = NULL;
+ }
+}
+
+static void
+run_destroy_handler (GtkDialog *dialog, gpointer data)
+{
+ RunInfo *ri = data;
+
+ shutdown_loop (ri);
+}
+
+static void
+run_response_handler (GtkDialog *dialog,
+ gint response_id,
+ gpointer data)
+{
+ RunInfo *ri;
+
+ ri = data;
+
+ ri->response_id = response_id;
+
+ shutdown_loop (ri);
+}
+
+static gint
+run_delete_handler (GtkDialog *dialog,
+ GdkEventAny *event,
+ gpointer data)
+{
+ RunInfo *ri = data;
+
+ shutdown_loop (ri);
+
+ /* emit response signal */
+ gtk_dialog_response (dialog, GTK_RESPONSE_NONE);
+
+ return TRUE; /* Do not destroy */
+}
+
+/**
+ * gtk_dialog_run:
+ * @dialog: a #GtkDialog
+ *
+ * Blocks in a recursive main loop until the @dialog either emits the
+ * response signal, or is destroyed. If the dialog is destroyed,
+ * gtk_dialog_run() returns GTK_RESPONSE_NONE. Otherwise, it returns
+ * the response ID from the "response" signal emission. Before
+ * entering the recursive main loop, gtk_dialog_run() calls
+ * gtk_widget_show() on the dialog for you. Note that you still
+ * need to show any children of the dialog yourself.
+ *
+ * During gtk_dialog_run(), the default behavior of "delete_event" is
+ * disabled; if the dialog receives "delete_event", it will not be
+ * destroyed as windows usually are, and gtk_dialog_run() will return
+ * GTK_RESPONSE_NONE. Also, during gtk_dialog_run() the dialog will be
+ * modal. You can force gtk_dialog_run() to return at any time by
+ * calling gtk_dialog_response() to emit the "response"
+ * signal. Destroying the dialog during gtk_dialog_run() is a very bad
+ * idea, because your post-run code won't know whether the dialog was
+ * destroyed or not.
+ *
+ * After gtk_dialog_run() returns, you are responsible for hiding or
+ * destroying the dialog if you wish to do so.
+ *
+ * Typical usage of this function might be:
+ * <programlisting>
+ * gint result = gtk_dialog_run (GTK_DIALOG (dialog));
+ * switch (result)
+ * {
+ * case GTK_RESPONSE_ACCEPT:
+ * do_application_specific_something ();
+ * break;
+ * default:
+ * do_nothing_since_dialog_was_cancelled ();
+ * break;
+ * }
+ * gtk_widget_destroy (dialog);
+ * </programlisting>
+ *
+ * Return value: response ID
+ **/
+gint
+gtk_dialog_run (GtkDialog *dialog)
+{
+ RunInfo ri = { NULL, GTK_RESPONSE_NONE, NULL };
+ gboolean was_modal;
+ guint response_handler;
+ guint destroy_handler;
+ guint delete_handler;
+
+ g_return_val_if_fail (GTK_IS_DIALOG (dialog), -1);
+
+ gtk_object_ref (GTK_OBJECT (dialog));
+
+ if (!GTK_WIDGET_VISIBLE (dialog))
+ gtk_widget_show (GTK_WIDGET (dialog));
+
+ was_modal = GTK_WINDOW (dialog)->modal;
+ if (!was_modal)
+ gtk_window_set_modal (GTK_WINDOW (dialog), TRUE);
+
+ response_handler =
+ gtk_signal_connect (GTK_OBJECT (dialog),
+ "response",
+ GTK_SIGNAL_FUNC (run_response_handler),
+ &ri);
+
+ destroy_handler =
+ gtk_signal_connect (GTK_OBJECT (dialog),
+ "destroy",
+ GTK_SIGNAL_FUNC (run_destroy_handler),
+ &ri);
+
+ delete_handler =
+ gtk_signal_connect (GTK_OBJECT (dialog),
+ "delete_event",
+ GTK_SIGNAL_FUNC (run_delete_handler),
+ &ri);
+
+ ri.loop = g_main_new (FALSE);
+
+ g_main_run (ri.loop);
+
+ g_assert (ri.loop == NULL);
+
+ if (!GTK_OBJECT_DESTROYED (dialog))
+ {
+ if (!was_modal)
+ gtk_window_set_modal (GTK_WINDOW(dialog), FALSE);
+
+ gtk_signal_disconnect (GTK_OBJECT (dialog), destroy_handler);
+ gtk_signal_disconnect (GTK_OBJECT (dialog), response_handler);
+ gtk_signal_disconnect (GTK_OBJECT (dialog), delete_handler);
+ }
+
+ gtk_object_unref (GTK_OBJECT (dialog));
+
+ return ri.response_id;
+}
+
+
+
+
extern "C" {
#endif /* __cplusplus */
+/* Parameters for dialog construction */
+typedef enum
+{
+ GTK_DIALOG_MODAL, /* call gtk_window_set_modal (win, TRUE) */
+ GTK_DIALOG_DESTROY_WITH_PARENT /* call gtk_window_set_destroy_with_parent () */
+
+} GtkDialogFlags;
+
+/* Convenience enum to use for action_id's. Positive values are
+ * totally user-interpreted. GTK will sometimes return
+ * GTK_ACTION_NONE if no action_id is available.
+ *
+ * Typical usage is:
+ * if (gtk_dialog_run(dialog) == GTK_ACTION_ACCEPT)
+ * blah();
+ */
+typedef enum
+{
+ /* GTK returns this if a response widget has no response_id,
+ * or the dialog gets destroyed with no response
+ */
+ GTK_RESPONSE_NONE = -1,
+ /* GTK won't return these unless you pass them in
+ * as the response for an action widget
+ */
+ GTK_RESPONSE_REJECT = -2,
+ GTK_RESPONSE_ACCEPT = -3
+} GtkResponseType;
+
#define GTK_TYPE_DIALOG (gtk_dialog_get_type ())
#define GTK_DIALOG(obj) (GTK_CHECK_CAST ((obj), GTK_TYPE_DIALOG, GtkDialog))
typedef struct _GtkDialog GtkDialog;
typedef struct _GtkDialogClass GtkDialogClass;
-typedef struct _GtkDialogButton GtkDialogButton;
-
struct _GtkDialog
{
struct _GtkDialogClass
{
GtkWindowClass parent_class;
+
+ void (* response) (GtkDialog *dialog, gint response_id);
};
GtkType gtk_dialog_get_type (void) G_GNUC_CONST;
GtkWidget* gtk_dialog_new (void);
+GtkWidget* gtk_dialog_new_with_buttons (const gchar *title,
+ GtkWindow *parent,
+ GtkDialogFlags flags,
+ const gchar *first_button_text,
+ ...);
+
+void gtk_dialog_add_action_widget (GtkDialog *dialog,
+ GtkWidget *child,
+ gint response_id);
+
+void gtk_dialog_add_button (GtkDialog *dialog,
+ const gchar *button_text,
+ gint response_id);
+
+void gtk_dialog_add_buttons (GtkDialog *dialog,
+ const gchar *first_button_text,
+ ...);
+
+/* Emit response signal */
+void gtk_dialog_response (GtkDialog *dialog,
+ gint response_id);
+
+/* Returns response_id */
+gint gtk_dialog_run (GtkDialog *dialog);
#ifdef __cplusplus
}
GTK_WIN_POS_NONE,
GTK_WIN_POS_CENTER,
GTK_WIN_POS_MOUSE,
- GTK_WIN_POS_CENTER_ALWAYS
+ GTK_WIN_POS_CENTER_ALWAYS,
+ GTK_WIN_POS_CENTER_ON_PARENT
} GtkWindowPosition;
/* Window types */
--- /dev/null
+/* GTK - The GIMP Toolkit
+ * Copyright (C) 2000 Red Hat, Inc.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+/*
+ * Modified by the GTK+ Team and others 1997-1999. See the AUTHORS
+ * file for a list of people on the GTK+ Team. See the ChangeLog
+ * files for a list of changes. These files are distributed with
+ * GTK+ at ftp://ftp.gtk.org/pub/gtk/.
+ */
+
+#include "gtkmessagedialog.h"
+#include "gtklabel.h"
+#include "gtkhbox.h"
+#include "gtkimage.h"
+#include "gtkstock.h"
+#include "gtkiconfactory.h"
+
+static void gtk_message_dialog_class_init (GtkMessageDialogClass *klass);
+static void gtk_message_dialog_init (GtkMessageDialog *dialog);
+
+
+GtkType
+gtk_message_dialog_get_type (void)
+{
+ static GtkType dialog_type = 0;
+
+ if (!dialog_type)
+ {
+ static const GtkTypeInfo dialog_info =
+ {
+ "GtkMessageDialog",
+ sizeof (GtkMessageDialog),
+ sizeof (GtkMessageDialogClass),
+ (GtkClassInitFunc) gtk_message_dialog_class_init,
+ (GtkObjectInitFunc) gtk_message_dialog_init,
+ /* reserved_1 */ NULL,
+ /* reserved_2 */ NULL,
+ (GtkClassInitFunc) NULL,
+ };
+
+ dialog_type = gtk_type_unique (GTK_TYPE_DIALOG, &dialog_info);
+ }
+
+ return dialog_type;
+}
+
+static void
+gtk_message_dialog_class_init (GtkMessageDialogClass *class)
+{
+}
+
+static void
+gtk_message_dialog_init (GtkMessageDialog *dialog)
+{
+ GtkWidget *hbox;
+
+ dialog->label = gtk_label_new (NULL);
+ dialog->image = gtk_image_new_from_stock (NULL, GTK_ICON_SIZE_DIALOG);
+
+ gtk_label_set_line_wrap (GTK_LABEL (dialog->label), TRUE);
+
+ hbox = gtk_hbox_new (FALSE, 10);
+
+ gtk_container_set_border_width (GTK_CONTAINER (hbox), 10);
+
+ gtk_box_pack_start (GTK_BOX (hbox), dialog->image,
+ FALSE, FALSE, 2);
+
+ gtk_box_pack_start (GTK_BOX (hbox), dialog->label,
+ TRUE, TRUE, 2);
+
+ gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->vbox),
+ hbox,
+ FALSE, FALSE, 10);
+
+ gtk_widget_show_all (hbox);
+}
+
+static void
+setup_type(GtkMessageDialog *dialog, GtkMessageType type)
+{
+ /* Note: this function can be called more than once,
+ * and after showing the dialog, due to object args
+ */
+
+ const gchar *stock_id = NULL;
+ GtkStockItem item;
+
+ switch (type)
+ {
+ case GTK_MESSAGE_INFO:
+ stock_id = GTK_STOCK_DIALOG_INFO;
+ break;
+
+ case GTK_MESSAGE_QUESTION:
+ stock_id = GTK_STOCK_DIALOG_QUESTION;
+ break;
+
+ case GTK_MESSAGE_WARNING:
+ stock_id = GTK_STOCK_DIALOG_WARNING;
+ break;
+
+ case GTK_MESSAGE_ERROR:
+ stock_id = GTK_STOCK_DIALOG_ERROR;
+ break;
+
+ default:
+ g_warning ("Unknown GtkMessageType %d", type);
+ break;
+ }
+
+ if (stock_id == NULL)
+ stock_id = GTK_STOCK_DIALOG_INFO;
+
+ if (gtk_stock_lookup (stock_id, &item))
+ {
+ gtk_image_set_from_stock (GTK_IMAGE (dialog->image), stock_id,
+ GTK_ICON_SIZE_DIALOG);
+
+ gtk_window_set_title (GTK_WINDOW (dialog), item.label);
+ }
+ else
+ g_warning ("Stock dialog ID doesn't exist?");
+}
+
+/**
+ * gtk_message_dialog_new:
+ * @parent: transient parent, or NULL for none
+ * @flags: flags
+ * @type: type of message
+ * @buttons: set of buttons to use
+ * @message_format: printf()-style format string, or NULL
+ * @Varargs: arguments for @message_format
+ *
+ * Creates a new message dialog, which is a simple dialog with an icon
+ * indicating the dialog type (error, warning, etc.) and some text the
+ * user may want to see. If the button set you select with the @buttons
+ * argument has positive buttons (OK, Yes) they will result in a response ID
+ * of GTK_RESPONSE_ACCEPT. If it has negative buttons (Cancel, No) they will
+ * result in a response ID of GTK_RESPONSE_REJECT. See #GtkDialog for more
+ * details.
+ *
+ * Return value: a new #GtkMessageDialog
+ **/
+GtkWidget*
+gtk_message_dialog_new (GtkWindow *parent,
+ GtkDialogFlags flags,
+ GtkMessageType type,
+ GtkButtonsType buttons,
+ const gchar *message_format,
+ ...)
+{
+ GtkWidget *widget;
+ GtkDialog *dialog;
+ gchar* msg;
+ va_list args;
+
+ widget = GTK_WIDGET (gtk_type_new (GTK_TYPE_MESSAGE_DIALOG));
+ dialog = GTK_DIALOG (widget);
+
+ if (message_format)
+ {
+ va_start (args, message_format);
+ msg = g_strdup_vprintf(message_format, args);
+ va_end (args);
+
+
+ gtk_label_set_text (GTK_LABEL (GTK_MESSAGE_DIALOG (widget)->label),
+ msg);
+
+ g_free (msg);
+ }
+
+ if (parent != NULL)
+ gtk_window_set_transient_for (GTK_WINDOW (widget),
+ GTK_WINDOW (parent));
+
+
+ if (flags & GTK_DIALOG_MODAL)
+ gtk_window_set_modal (GTK_WINDOW (dialog), TRUE);
+
+ if (flags & GTK_DIALOG_DESTROY_WITH_PARENT)
+ gtk_window_set_destroy_with_parent (GTK_WINDOW (dialog), TRUE);
+
+ setup_type (GTK_MESSAGE_DIALOG (dialog), type);
+
+ switch (buttons)
+ {
+ case GTK_BUTTONS_NONE:
+ /* nothing */
+ break;
+
+ case GTK_BUTTONS_OK:
+ gtk_dialog_add_button (dialog,
+ GTK_STOCK_BUTTON_OK,
+ GTK_RESPONSE_ACCEPT);
+ break;
+
+ case GTK_BUTTONS_CLOSE:
+ gtk_dialog_add_button (dialog,
+ GTK_STOCK_BUTTON_CLOSE,
+ GTK_RESPONSE_ACCEPT);
+ break;
+
+ case GTK_BUTTONS_CANCEL:
+ gtk_dialog_add_button (dialog,
+ GTK_STOCK_BUTTON_CANCEL,
+ GTK_RESPONSE_REJECT);
+ break;
+
+ case GTK_BUTTONS_YES_NO:
+ gtk_dialog_add_button (dialog,
+ GTK_STOCK_BUTTON_YES,
+ GTK_RESPONSE_ACCEPT);
+ gtk_dialog_add_button (dialog,
+ GTK_STOCK_BUTTON_NO,
+ GTK_RESPONSE_REJECT);
+ break;
+
+ case GTK_BUTTONS_OK_CANCEL:
+ gtk_dialog_add_button (dialog,
+ GTK_STOCK_BUTTON_OK,
+ GTK_RESPONSE_ACCEPT);
+ gtk_dialog_add_button (dialog,
+ GTK_STOCK_BUTTON_CANCEL,
+ GTK_RESPONSE_REJECT);
+ break;
+
+ default:
+ g_warning ("Unknown GtkButtonsType");
+ break;
+ }
+
+ return widget;
+}
--- /dev/null
+/* GTK - The GIMP Toolkit
+ * Copyright (C) 2000 Red Hat, Inc.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+/*
+ * Modified by the GTK+ Team and others 1997-2000. See the AUTHORS
+ * file for a list of people on the GTK+ Team. See the ChangeLog
+ * files for a list of changes. These files are distributed with
+ * GTK+ at ftp://ftp.gtk.org/pub/gtk/.
+ */
+
+#ifndef __GTK_MESSAGE_DIALOG_H__
+#define __GTK_MESSAGE_DIALOG_H__
+
+#include <gtk/gtkdialog.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+typedef enum
+{
+ GTK_MESSAGE_INFO,
+ GTK_MESSAGE_WARNING,
+ GTK_MESSAGE_QUESTION,
+ GTK_MESSAGE_ERROR
+} GtkMessageType;
+
+typedef enum
+{
+ GTK_BUTTONS_NONE,
+ GTK_BUTTONS_OK,
+ GTK_BUTTONS_CLOSE,
+ GTK_BUTTONS_CANCEL,
+ GTK_BUTTONS_YES_NO,
+ GTK_BUTTONS_OK_CANCEL
+} GtkButtonsType;
+
+#define GTK_TYPE_MESSAGE_DIALOG (gtk_message_dialog_get_type ())
+#define GTK_MESSAGE_DIALOG(obj) (GTK_CHECK_CAST ((obj), GTK_TYPE_MESSAGE_DIALOG, GtkMessageDialog))
+#define GTK_MESSAGE_DIALOG_CLASS(klass) (GTK_CHECK_CLASS_CAST ((klass), GTK_TYPE_MESSAGE_DIALOG, GtkMessageDialogClass))
+#define GTK_IS_MESSAGE_DIALOG(obj) (GTK_CHECK_TYPE ((obj), GTK_TYPE_MESSAGE_DIALOG))
+#define GTK_IS_MESSAGE_DIALOG_CLASS(klass) (GTK_CHECK_CLASS_TYPE ((klass), GTK_TYPE_MESSAGE_DIALOG))
+#define GTK_MESSAGE_DIALOG_GET_CLASS(obj) (GTK_CHECK_GET_CLASS ((obj), GTK_TYPE_MESSAGE_DIALOG, GtkMessageDialogClass))
+
+
+typedef struct _GtkMessageDialog GtkMessageDialog;
+typedef struct _GtkMessageDialogClass GtkMessageDialogClass;
+
+struct _GtkMessageDialog
+{
+ /*< private >*/
+
+ GtkDialog parent_instance;
+
+ GtkWidget *image;
+ GtkWidget *label;
+};
+
+struct _GtkMessageDialogClass
+{
+ GtkDialogClass parent_class;
+
+
+};
+
+GtkType gtk_message_dialog_get_type (void);
+
+GtkWidget* gtk_message_dialog_new (GtkWindow *parent,
+ GtkDialogFlags flags,
+ GtkMessageType type,
+ GtkButtonsType buttons,
+ const gchar *message_format,
+ ...) G_GNUC_PRINTF (5, 6);
+
+
+
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#endif /* __GTK_MESSAGE_DIALOG_H__ */
#include "gtkwindow.h"
#include "gtkbindings.h"
#include "gtkmain.h"
+#include "gtkiconfactory.h"
/* TODO: remove this define and assorted code in 1.3 and fix up the
* real culprits.
ARG_MODAL,
ARG_WIN_POS,
ARG_DEFAULT_WIDTH,
- ARG_DEFAULT_HEIGHT
+ ARG_DEFAULT_HEIGHT,
+ ARG_DESTROY_WITH_PARENT
};
typedef struct {
gtk_object_add_arg_type ("GtkWindow::window_position", GTK_TYPE_WINDOW_POSITION, GTK_ARG_READWRITE, ARG_WIN_POS);
gtk_object_add_arg_type ("GtkWindow::default_width", GTK_TYPE_INT, GTK_ARG_READWRITE, ARG_DEFAULT_WIDTH);
gtk_object_add_arg_type ("GtkWindow::default_height", GTK_TYPE_INT, GTK_ARG_READWRITE, ARG_DEFAULT_HEIGHT);
+ gtk_object_add_arg_type ("GtkWindow::destroy_with_parent", GTK_TYPE_BOOL, GTK_ARG_READWRITE, ARG_DESTROY_WITH_PARENT);
window_signals[SET_FOCUS] =
gtk_signal_new ("set_focus",
case ARG_DEFAULT_HEIGHT:
gtk_window_set_default_size (window, -2, GTK_VALUE_INT (*arg));
break;
+ case ARG_DESTROY_WITH_PARENT:
+ gtk_window_set_destroy_with_parent (window, GTK_VALUE_BOOL (*arg));
+ break;
default:
break;
}
else
GTK_VALUE_INT (*arg) = info->height;
break;
+ case ARG_DESTROY_WITH_PARENT:
+ GTK_VALUE_BOOL (*arg) = window->destroy_with_parent;
+ break;
default:
arg->type = GTK_TYPE_INVALID;
break;
gtk_accel_group_detach (accel_group, GTK_OBJECT (window));
}
+GtkAccelGroup*
+gtk_window_get_default_accel_group (GtkWindow *window)
+{
+ GtkAccelGroup *group;
+
+ g_return_val_if_fail (GTK_IS_WINDOW (window), NULL);
+
+ group = gtk_object_get_data (GTK_OBJECT (window),
+ "gtk-accel-group");
+
+ if (group == NULL)
+ {
+ group = gtk_accel_group_new ();
+ gtk_window_add_accel_group (window, group);
+ gtk_object_set_data (GTK_OBJECT (window),
+ "gtk-accel-group",
+ group);
+ gtk_accel_group_unref (group);
+ }
+
+ return group;
+}
+
void
gtk_window_set_position (GtkWindow *window,
GtkWindowPosition position)
G_OBJECT_CLASS (parent_class)->shutdown (object);
}
+static void
+parent_destroyed_callback (GtkWindow *parent, GtkWindow *child)
+{
+ gtk_widget_destroy (GTK_WIDGET (child));
+}
+
+static void
+connect_parent_destroyed (GtkWindow *window)
+{
+ if (window->transient_parent)
+ {
+ gtk_signal_connect (GTK_OBJECT (window->transient_parent),
+ "destroy",
+ GTK_SIGNAL_FUNC (parent_destroyed_callback),
+ window);
+ }
+}
+
+static void
+disconnect_parent_destroyed (GtkWindow *window)
+{
+ if (window->transient_parent)
+ {
+ gtk_signal_disconnect_by_func (GTK_OBJECT (window->transient_parent),
+ GTK_SIGNAL_FUNC (parent_destroyed_callback),
+ window);
+ }
+}
+
static void
gtk_window_transient_parent_realized (GtkWidget *parent,
GtkWidget *window)
GTK_SIGNAL_FUNC (gtk_widget_destroyed),
&window->transient_parent);
+ if (window->destroy_with_parent)
+ disconnect_parent_destroyed (window);
+
window->transient_parent = NULL;
}
}
gtk_window_set_transient_for (GtkWindow *window,
GtkWindow *parent)
{
- g_return_if_fail (window != 0);
+ g_return_if_fail (GTK_IS_WINDOW (window));
+ g_return_if_fail (parent == NULL || GTK_IS_WINDOW (parent));
+ g_return_if_fail (window != parent);
+
if (window->transient_parent)
{
if (GTK_WIDGET_REALIZED (window) &&
GTK_SIGNAL_FUNC (gtk_window_transient_parent_unrealized),
window);
+ if (window->destroy_with_parent)
+ connect_parent_destroyed (window);
+
if (GTK_WIDGET_REALIZED (window) &&
GTK_WIDGET_REALIZED (parent))
gtk_window_transient_parent_realized (GTK_WIDGET (parent),
}
}
+/**
+ * gtk_window_set_destroy_with_parent:
+ * @window: a #GtkWindow
+ * @setting: whether to destroy @window with its transient parent
+ *
+ * If @setting is TRUE, then destroying the transient parent of @window
+ * will also destroy @window itself. This is useful for dialogs that
+ * shouldn't persist beyond the lifetime of the main window they're
+ * associated with, for example.
+ **/
+void
+gtk_window_set_destroy_with_parent (GtkWindow *window,
+ gboolean setting)
+{
+ g_return_if_fail (GTK_IS_WINDOW (window));
+
+ if (window->destroy_with_parent == (setting != FALSE))
+ return;
+
+ if (window->destroy_with_parent)
+ {
+ disconnect_parent_destroyed (window);
+ }
+ else
+ {
+ connect_parent_destroyed (window);
+ }
+
+ window->destroy_with_parent = setting;
+}
+
static void
gtk_window_geometry_destroy (GtkWindowGeometryInfo *info)
{
window = GTK_WINDOW (object);
if (window->transient_parent)
- gtk_window_unset_transient_for (window);
+ gtk_window_set_transient_for (window, NULL);
if (window->has_user_ref_count)
{
* of date, so we need to reset all our widgets. Our other
* toplevel windows will also get the message, but by
* then, the RC file will up to date, so we have to tell
- * them now.
+ * them now. Also, we have to invalidate cached icons in
+ * icon sets so they get re-rendered.
*/
- GList *list, *toplevels = gtk_window_list_toplevels ();
+ GList *list, *toplevels;
+ _gtk_icon_set_invalidate_caches ();
+
+ toplevels = gtk_window_list_toplevels ();
+
for (list = toplevels; list; list = list->next)
{
gtk_widget_reset_rc_styles (list->data);
gint *y)
{
GtkWidget *widget;
-
+ GtkWindowPosition pos;
+ GtkWidget *parent_widget;
+
widget = GTK_WIDGET (window);
*x = -1;
*y = -1;
+
+ parent_widget = (GtkWidget*) window->transient_parent;
- switch (window->position)
- {
+ pos = window->position;
+ if (pos == GTK_WIN_POS_CENTER_ON_PARENT &&
+ (parent_widget == NULL ||
+ !GTK_WIDGET_MAPPED (parent_widget)))
+ pos = GTK_WIN_POS_NONE;
+
+ switch (pos)
+ {
case GTK_WIN_POS_CENTER:
case GTK_WIN_POS_CENTER_ALWAYS:
if (window->use_uposition)
*y = (screen_height - new_height) / 2;
}
break;
+
+ case GTK_WIN_POS_CENTER_ON_PARENT:
+ if (window->use_uposition)
+ {
+ gint ox, oy;
+ gdk_window_get_origin (parent_widget->window,
+ &ox, &oy);
+
+ *x = ox + (parent_widget->allocation.width - new_width) / 2;
+ *y = oy + (parent_widget->allocation.height - new_height) / 2;
+ }
+ break;
+
case GTK_WIN_POS_MOUSE:
if (window->use_uposition)
{
*/
guint use_uposition : 1;
guint modal : 1;
+ guint destroy_with_parent : 1;
};
struct _GtkWindowClass
void gtk_window_set_transient_for (GtkWindow *window,
GtkWindow *parent);
+void gtk_window_set_destroy_with_parent (GtkWindow *window,
+ gboolean setting);
void gtk_window_set_geometry_hints (GtkWindow *window,
GtkWidget *geometry_widget,
GdkGeometry *geometry,
gboolean modal);
GList* gtk_window_list_toplevels (void);
+/* Get the "built-in" accel group (convenience thing) */
+GtkAccelGroup* gtk_window_get_default_accel_group (GtkWindow *window);
/* --- internal functions --- */
void gtk_window_set_focus (GtkWindow *window,
if (!window)
{
+ GtkAccelGroup *accel_group;
+
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+ accel_group = gtk_window_get_default_accel_group (GTK_WINDOW (window));
+
gtk_signal_connect (GTK_OBJECT (window), "destroy",
GTK_SIGNAL_FUNC (gtk_widget_destroyed),
&window);
gtk_box_pack_start (GTK_BOX (box1), table, TRUE, TRUE, 0);
button[0] = gtk_button_new_with_label ("button1");
- button[1] = gtk_button_new_with_label ("button2");
+ button[1] = gtk_button_new_accel ("_button2", accel_group);
button[2] = gtk_button_new_with_label ("button3");
- button[3] = gtk_button_new_with_label ("button4");
+ button[3] = gtk_button_new_stock (GTK_STOCK_BUTTON_OK, NULL);
button[4] = gtk_button_new_with_label ("button5");
button[5] = gtk_button_new_with_label ("button6");
button[6] = gtk_button_new_with_label ("button7");
- button[7] = gtk_button_new_with_label ("button8");
+ button[7] = gtk_button_new_stock (GTK_STOCK_BUTTON_CLOSE, accel_group);
button[8] = gtk_button_new_with_label ("button9");
-
+
gtk_signal_connect (GTK_OBJECT (button[0]), "clicked",
GTK_SIGNAL_FUNC(button_window),
button[1]);
gtk_widget_destroy (window);
}
+/*
+ * GtkImage
+ */
+
+static void
+pack_image (GtkWidget *box,
+ const gchar *text,
+ GtkWidget *image)
+{
+ gtk_box_pack_start (GTK_BOX (box),
+ gtk_label_new (text),
+ FALSE, FALSE, 0);
+
+ gtk_box_pack_start (GTK_BOX (box),
+ image,
+ TRUE, TRUE, 0);
+}
+
+static void
+create_image (void)
+{
+ static GtkWidget *window = NULL;
+
+ if (window == NULL)
+ {
+ GtkWidget *vbox;
+ GdkPixmap *pixmap;
+ GdkBitmap *mask;
+
+ window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+
+ gtk_signal_connect (GTK_OBJECT (window), "destroy",
+ GTK_SIGNAL_FUNC(gtk_widget_destroyed),
+ &window);
+
+ vbox = gtk_vbox_new (FALSE, 5);
+
+ gtk_container_add (GTK_CONTAINER (window), vbox);
+
+ pack_image (vbox, "Stock Warning Dialog",
+ gtk_image_new_from_stock (GTK_STOCK_DIALOG_WARNING,
+ GTK_ICON_SIZE_DIALOG));
+
+ pixmap = gdk_pixmap_colormap_create_from_xpm_d (NULL,
+ gtk_widget_get_colormap (window),
+ &mask,
+ NULL,
+ openfile);
+
+ pack_image (vbox, "Pixmap",
+ gtk_image_new_from_pixmap (pixmap, mask));
+ }
+
+ if (!GTK_WIDGET_VISIBLE (window))
+ gtk_widget_show_all (window);
+ else
+ gtk_widget_destroy (window);
+}
+
/*
* Menu demo
*/
/* Pack widgets */
gtk_container_add (GTK_CONTAINER (window), box1);
- gtk_box_pack_start (GTK_BOX (box1), frame1, TRUE, TRUE, 4);
- gtk_container_add (GTK_CONTAINER (frame1), box2);
- gtk_box_pack_start (GTK_BOX (box2), btnColor, FALSE, FALSE, 4);
- gtk_box_pack_start (GTK_BOX (box2), btnFile, FALSE, FALSE, 4);
- gtk_box_pack_start (GTK_BOX (box1), gtk_hseparator_new (), FALSE, FALSE, 4);
- gtk_box_pack_start (GTK_BOX (box1), btnClose, FALSE, FALSE, 4);
+ gtk_box_pack_start (GTK_BOX (box1), frame1, TRUE, TRUE, 4);
+ gtk_container_add (GTK_CONTAINER (frame1), box2);
+ gtk_box_pack_start (GTK_BOX (box2), btnColor, FALSE, FALSE, 4);
+ gtk_box_pack_start (GTK_BOX (box2), btnFile, FALSE, FALSE, 4);
+ gtk_box_pack_start (GTK_BOX (box1), gtk_hseparator_new (), FALSE, FALSE, 4);
+ gtk_box_pack_start (GTK_BOX (box1), btnClose, FALSE, FALSE, 4);
/* connect signals */
gtk_signal_connect_object (GTK_OBJECT (btnClose), "clicked",
gtk_main();
}
+/*
+ * GtkMessageDialog
+ */
+
+static void
+make_message_dialog (GtkWidget **dialog,
+ GtkMessageType type,
+ GtkButtonsType buttons)
+{
+ if (*dialog)
+ {
+ if (GTK_WIDGET_REALIZED (*dialog))
+ gdk_window_show ((*dialog)->window);
+
+ return;
+ }
+
+ *dialog = gtk_message_dialog_new (NULL, 0, type, buttons,
+ "This is a message dialog; it can wrap long lines. This is a long line. La la la. Look this line is wrapped. Blah blah blah blah blah blah. (Note: testgtk has a nonstandard gtkrc that changes some of the message dialog icons.)");
+
+ gtk_signal_connect_object (GTK_OBJECT (*dialog),
+ "response",
+ GTK_SIGNAL_FUNC (gtk_widget_destroy),
+ GTK_OBJECT (*dialog));
+
+ gtk_signal_connect (GTK_OBJECT (*dialog),
+ "destroy",
+ GTK_SIGNAL_FUNC (gtk_widget_destroyed),
+ dialog);
+
+ gtk_widget_show (*dialog);
+}
+
+static void
+create_message_dialog (void)
+{
+ static GtkWidget *info = NULL;
+ static GtkWidget *warning = NULL;
+ static GtkWidget *error = NULL;
+ static GtkWidget *question = NULL;
+
+ make_message_dialog (&info, GTK_MESSAGE_INFO, GTK_BUTTONS_OK);
+ make_message_dialog (&warning, GTK_MESSAGE_WARNING, GTK_BUTTONS_CLOSE);
+ make_message_dialog (&error, GTK_MESSAGE_ERROR, GTK_BUTTONS_OK_CANCEL);
+ make_message_dialog (&question, GTK_MESSAGE_QUESTION, GTK_BUTTONS_YES_NO);
+}
+
/*
* GtkScrolledWindow
*/
{ "font selection", create_font_selection },
{ "gamma curve", create_gamma_curve },
{ "handle box", create_handle_box },
+ { "image", create_image },
{ "item factory", create_item_factory },
{ "labels", create_labels },
{ "layout", create_layout },
{ "list", create_list },
{ "menus", create_menus },
+ { "message dialog", create_message_dialog },
{ "modal window", create_modal_window },
{ "notebook", create_notebook },
{ "panes", create_panes },
gtk_init (&argc, &argv);
- gdk_rgb_init ();
-
/* bindings test
*/
binding_set = gtk_binding_set_by_class (gtk_type_class (GTK_TYPE_WIDGET));
font_name = "Sans 12"
}
+style "myicons"
+{
+ stock["gtk-dialog-warning"] =
+ {
+ { "3DRings.xpm", *, *, *}
+ }
+}
+
+class "GtkImage" style "myicons"
+
# common default
class "GtkWidget" style "defaultfont"
if (!window)
{
+ GtkAccelGroup *accel_group;
+
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+ accel_group = gtk_window_get_default_accel_group (GTK_WINDOW (window));
+
gtk_signal_connect (GTK_OBJECT (window), "destroy",
GTK_SIGNAL_FUNC (gtk_widget_destroyed),
&window);
gtk_box_pack_start (GTK_BOX (box1), table, TRUE, TRUE, 0);
button[0] = gtk_button_new_with_label ("button1");
- button[1] = gtk_button_new_with_label ("button2");
+ button[1] = gtk_button_new_accel ("_button2", accel_group);
button[2] = gtk_button_new_with_label ("button3");
- button[3] = gtk_button_new_with_label ("button4");
+ button[3] = gtk_button_new_stock (GTK_STOCK_BUTTON_OK, NULL);
button[4] = gtk_button_new_with_label ("button5");
button[5] = gtk_button_new_with_label ("button6");
button[6] = gtk_button_new_with_label ("button7");
- button[7] = gtk_button_new_with_label ("button8");
+ button[7] = gtk_button_new_stock (GTK_STOCK_BUTTON_CLOSE, accel_group);
button[8] = gtk_button_new_with_label ("button9");
-
+
gtk_signal_connect (GTK_OBJECT (button[0]), "clicked",
GTK_SIGNAL_FUNC(button_window),
button[1]);
gtk_widget_destroy (window);
}
+/*
+ * GtkImage
+ */
+
+static void
+pack_image (GtkWidget *box,
+ const gchar *text,
+ GtkWidget *image)
+{
+ gtk_box_pack_start (GTK_BOX (box),
+ gtk_label_new (text),
+ FALSE, FALSE, 0);
+
+ gtk_box_pack_start (GTK_BOX (box),
+ image,
+ TRUE, TRUE, 0);
+}
+
+static void
+create_image (void)
+{
+ static GtkWidget *window = NULL;
+
+ if (window == NULL)
+ {
+ GtkWidget *vbox;
+ GdkPixmap *pixmap;
+ GdkBitmap *mask;
+
+ window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+
+ gtk_signal_connect (GTK_OBJECT (window), "destroy",
+ GTK_SIGNAL_FUNC(gtk_widget_destroyed),
+ &window);
+
+ vbox = gtk_vbox_new (FALSE, 5);
+
+ gtk_container_add (GTK_CONTAINER (window), vbox);
+
+ pack_image (vbox, "Stock Warning Dialog",
+ gtk_image_new_from_stock (GTK_STOCK_DIALOG_WARNING,
+ GTK_ICON_SIZE_DIALOG));
+
+ pixmap = gdk_pixmap_colormap_create_from_xpm_d (NULL,
+ gtk_widget_get_colormap (window),
+ &mask,
+ NULL,
+ openfile);
+
+ pack_image (vbox, "Pixmap",
+ gtk_image_new_from_pixmap (pixmap, mask));
+ }
+
+ if (!GTK_WIDGET_VISIBLE (window))
+ gtk_widget_show_all (window);
+ else
+ gtk_widget_destroy (window);
+}
+
/*
* Menu demo
*/
/* Pack widgets */
gtk_container_add (GTK_CONTAINER (window), box1);
- gtk_box_pack_start (GTK_BOX (box1), frame1, TRUE, TRUE, 4);
- gtk_container_add (GTK_CONTAINER (frame1), box2);
- gtk_box_pack_start (GTK_BOX (box2), btnColor, FALSE, FALSE, 4);
- gtk_box_pack_start (GTK_BOX (box2), btnFile, FALSE, FALSE, 4);
- gtk_box_pack_start (GTK_BOX (box1), gtk_hseparator_new (), FALSE, FALSE, 4);
- gtk_box_pack_start (GTK_BOX (box1), btnClose, FALSE, FALSE, 4);
+ gtk_box_pack_start (GTK_BOX (box1), frame1, TRUE, TRUE, 4);
+ gtk_container_add (GTK_CONTAINER (frame1), box2);
+ gtk_box_pack_start (GTK_BOX (box2), btnColor, FALSE, FALSE, 4);
+ gtk_box_pack_start (GTK_BOX (box2), btnFile, FALSE, FALSE, 4);
+ gtk_box_pack_start (GTK_BOX (box1), gtk_hseparator_new (), FALSE, FALSE, 4);
+ gtk_box_pack_start (GTK_BOX (box1), btnClose, FALSE, FALSE, 4);
/* connect signals */
gtk_signal_connect_object (GTK_OBJECT (btnClose), "clicked",
gtk_main();
}
+/*
+ * GtkMessageDialog
+ */
+
+static void
+make_message_dialog (GtkWidget **dialog,
+ GtkMessageType type,
+ GtkButtonsType buttons)
+{
+ if (*dialog)
+ {
+ if (GTK_WIDGET_REALIZED (*dialog))
+ gdk_window_show ((*dialog)->window);
+
+ return;
+ }
+
+ *dialog = gtk_message_dialog_new (NULL, 0, type, buttons,
+ "This is a message dialog; it can wrap long lines. This is a long line. La la la. Look this line is wrapped. Blah blah blah blah blah blah. (Note: testgtk has a nonstandard gtkrc that changes some of the message dialog icons.)");
+
+ gtk_signal_connect_object (GTK_OBJECT (*dialog),
+ "response",
+ GTK_SIGNAL_FUNC (gtk_widget_destroy),
+ GTK_OBJECT (*dialog));
+
+ gtk_signal_connect (GTK_OBJECT (*dialog),
+ "destroy",
+ GTK_SIGNAL_FUNC (gtk_widget_destroyed),
+ dialog);
+
+ gtk_widget_show (*dialog);
+}
+
+static void
+create_message_dialog (void)
+{
+ static GtkWidget *info = NULL;
+ static GtkWidget *warning = NULL;
+ static GtkWidget *error = NULL;
+ static GtkWidget *question = NULL;
+
+ make_message_dialog (&info, GTK_MESSAGE_INFO, GTK_BUTTONS_OK);
+ make_message_dialog (&warning, GTK_MESSAGE_WARNING, GTK_BUTTONS_CLOSE);
+ make_message_dialog (&error, GTK_MESSAGE_ERROR, GTK_BUTTONS_OK_CANCEL);
+ make_message_dialog (&question, GTK_MESSAGE_QUESTION, GTK_BUTTONS_YES_NO);
+}
+
/*
* GtkScrolledWindow
*/
{ "font selection", create_font_selection },
{ "gamma curve", create_gamma_curve },
{ "handle box", create_handle_box },
+ { "image", create_image },
{ "item factory", create_item_factory },
{ "labels", create_labels },
{ "layout", create_layout },
{ "list", create_list },
{ "menus", create_menus },
+ { "message dialog", create_message_dialog },
{ "modal window", create_modal_window },
{ "notebook", create_notebook },
{ "panes", create_panes },
gtk_init (&argc, &argv);
- gdk_rgb_init ();
-
/* bindings test
*/
binding_set = gtk_binding_set_by_class (gtk_type_class (GTK_TYPE_WIDGET));
font_name = "Sans 12"
}
+style "myicons"
+{
+ stock["gtk-dialog-warning"] =
+ {
+ { "3DRings.xpm", *, *, *}
+ }
+}
+
+class "GtkImage" style "myicons"
+
# common default
class "GtkWidget" style "defaultfont"
projects / gtk4.git / commitdiff